﻿
#include "DNF定义.h"
#include "Engine/common.h"
#include "strid.h"

#pragma warning(disable:4305)

class DNF技能对象_四象引 : public DNF技能对象
{
public:
	virtual void 初始化()
	{
		索引=四象引;
		名称=L"四象引";
		所属职业=职业_流浪武士;
		技能类型=主动技能;
		可用护石=FALSE;
		可用符文=TRUE;
		可用TP=TRUE;

		学习等级=20;
		等级上限=70;
		精通等级=60;
		版本等级=48;
		TP学习等级=55;
		TP等级上限=9;
		TP精通等级=7;

		无色数量=0;
		手搓冷却缩减=PC(1);
		冷却时间=7.0f;

		float 数据表1[技能等级上限]={
			0.0f,
			57.98, 63.92, 69.57, 75.53, 81.46,  87.25, 93.18, 99.15, 105.07, 110.84, 
			116.78, 122.56, 128.38, 134.31, 140.25,  146.05, 151.99, 157.93, 163.87, 169.55, 
			175.45, 181.38, 187.20, 193.11, 199.07,  204.84, 210.80, 216.71, 222.36, 228.33, 
			234.26, 240.20, 245.99, 251.94, 257.85,  263.65, 269.47, 275.40, 281.21, 287.13, 
			293.09, 299.02, 304.80, 310.74, 316.65,  322.33, 328.30, 334.18, 339.98, 345.94, 
			351.87, 357.69, 363.59, 369.53, 375.32,  381.14, 387.05, 393.02, 398.84, 404.74, 
			410.66, 416.31, 422.29, 428.21, 434.18,  439.92, 445.87, 451.82, 457.59, 463.52, 
		};
		数据表数量=1;
		数据表[0]=数据表1;

		ResId=RID_技能图标_剑帝+四象引;
		符文起始ResId=RID_符文图标_剑帝+四象引符文*5;
		白金徽章可选=TRUE;
		时装上衣可选=TRUE;
	}

	virtual float 获取伤害(int 等级,int TP等级=0,BOOL 应用护石=FALSE)
	{
		float 基础伤害=(数据表[0])[等级];		//抓取和冲击波二选一
		float TP增伤=1.0+TP等级*PC(10);
		return 基础伤害*TP增伤;
	}

	virtual float 获取冷却(BOOL 应用护石=FALSE)
	{
		return 冷却时间;
	}
};

class DNF技能对象_一花渡江 : public DNF技能对象
{
public:
	virtual void 初始化()
	{
		索引=一花渡江;
		名称=L"一花渡江";
		所属职业=职业_流浪武士;
		技能类型=主动技能;
		可用护石=FALSE;
		可用符文=TRUE;
		可用TP=TRUE;

		学习等级=25;
		等级上限=70;
		精通等级=60;
		版本等级=46;
		TP学习等级=55;
		TP等级上限=9;
		TP精通等级=7;

		无色数量=0;
		手搓冷却缩减=PC(1);
		冷却时间=6.0f;

		float 数据表1[技能等级上限]={
			0.0f,
			17.68, 19.46, 21.25, 23.05, 24.86,  26.65, 28.43, 30.23, 32.02, 33.82, 
			35.60, 37.42, 39.20, 41.00, 42.77,  44.59, 46.37, 48.17, 49.95, 51.74, 
			53.54, 55.34, 57.13, 58.92, 60.71,  62.52, 64.32, 66.09, 67.89, 69.68, 
			71.49, 73.27, 75.08, 76.86, 78.66,  80.43, 82.25, 84.03, 85.83, 87.61, 
			89.42, 91.21, 93.01, 94.81, 96.59,  98.38, 100.16, 101.99, 103.75, 105.56, 
			107.34, 109.14, 110.93, 112.73, 114.53,  116.32, 118.10, 119.89, 121.71, 123.50, 
			125.28, 127.07, 128.87, 130.65, 132.45,  134.25, 136.04, 137.85, 139.61, 141.44, 
		};
		数据表数量=1;
		数据表[0]=数据表1;

		ResId=RID_技能图标_剑帝+一花渡江;
		符文起始ResId=RID_符文图标_剑帝+一花渡江符文*5;
		白金徽章可选=TRUE;
		时装上衣可选=TRUE;
	}

	virtual float 获取伤害(int 等级,int TP等级=0,BOOL 应用护石=FALSE)
	{
		float 基础伤害=(数据表[0])[等级]*3;	//3段
		float TP增伤=1.0+TP等级*PC(10);
		return 基础伤害*TP增伤;
	}

	virtual float 获取冷却(BOOL 应用护石=FALSE)
	{
		return 冷却时间-1.0f;	//三觉被动-1s（应该放到职业类处理，三觉被动可能设为0级）
	}
};

class DNF技能对象_樱落斩 : public DNF技能对象
{
public:
	virtual void 初始化()
	{
		索引=樱落斩;
		名称=L"樱落斩";
		所属职业=职业_流浪武士;
		技能类型=主动技能;
		可用护石=FALSE;
		可用符文=TRUE;
		可用TP=TRUE;

		学习等级=25;
		等级上限=70;
		精通等级=60;
		版本等级=46;
		TP学习等级=55;
		TP等级上限=9;
		TP精通等级=7;

		无色数量=0;
		手搓冷却缩减=PC(1);
		冷却时间=7.0f;

		float 数据表1[技能等级上限]={
			0.0f,
			6.94, 7.58, 8.33, 9.03, 9.82,  10.44, 11.23, 11.91, 12.59, 13.35, 
			14.01, 14.74, 15.45, 16.18, 16.84,  17.57, 18.33, 18.97, 19.73, 20.44, 
			21.15, 21.87, 22.58, 23.29, 23.99,  24.71, 25.43, 26.13, 26.88, 27.54, 
			28.27, 29.02, 29.69, 30.43, 31.10,  31.85, 32.55, 33.24, 33.98, 34.67, 
			35.38, 36.10, 36.85, 37.48, 38.27,  38.97, 39.70, 40.38, 41.08, 41.85, 
			42.49, 43.23, 43.92, 44.62, 45.39,  46.05, 46.81, 47.50, 48.22, 48.90, 
			49.62, 50.35, 51.05, 51.78, 52.47,  53.19, 53.95, 54.59, 55.36, 56.07, 
		};

		float 数据表2[技能等级上限]={
			0.0f,
			9.27, 10.19, 11.09, 12.03, 13.02,  13.96, 14.86, 15.87, 16.80, 17.76, 
			18.66, 19.69, 20.61, 21.53, 22.49,  23.46, 24.40, 25.29, 26.28, 27.24, 
			28.24, 29.15, 30.09, 31.04, 31.98,  32.91, 33.87, 34.84, 35.80, 36.71, 
			37.73, 38.64, 39.58, 40.53, 41.50,  42.45, 43.35, 44.33, 45.27, 46.25, 
			47.20, 48.17, 49.07, 50.01, 50.95,  51.90, 52.86, 53.84, 54.75, 55.74, 
			56.69, 57.61, 58.56, 59.50, 60.48,  61.39, 62.34, 63.30, 64.28, 65.23, 
			66.19, 67.13, 68.04, 69.01, 69.94,  70.90, 71.91, 72.78, 73.76, 74.71, 
		};

		float 数据表3[技能等级上限]={
			0.0f,
			2.63, 2.91, 3.18, 3.42, 3.75,  3.97, 4.29, 4.54, 4.79, 5.07, 
			5.33, 5.62, 5.89, 6.13, 6.44,  6.68, 6.97, 7.25, 7.53, 7.76, 
			8.07, 8.33, 8.63, 8.90, 9.11,  9.42, 9.68, 9.95, 10.22, 10.48, 
			10.78, 11.06, 11.29, 11.60, 11.84,  12.14, 12.41, 12.69, 12.94, 13.20, 
			13.46, 13.76, 14.01, 14.29, 14.56,  14.84, 15.10, 15.38, 15.62, 15.95, 
			16.21, 16.44, 16.77, 17.00, 17.27,  17.56, 17.78, 18.09, 18.36, 18.64, 
			18.94, 19.21, 19.45, 19.72, 20.00,  20.28, 20.54, 20.80, 21.10, 21.34, 
		};

		float 数据表4[技能等级上限]={
			0.0f,
			18.40, 20.29, 22.16, 24.06, 26.03,  27.82, 29.78, 31.69, 33.60, 35.49, 
			37.34, 39.25, 41.15, 43.03, 45.00,  46.87, 48.80, 50.65, 52.57, 54.42, 
			56.37, 58.25, 60.13, 62.12, 63.89,  65.86, 67.77, 69.64, 71.56, 73.40, 
			75.34, 77.22, 79.10, 81.08, 82.97,  84.86, 86.74, 88.62, 90.52, 92.44, 
			94.33, 96.19, 98.17, 99.97, 101.94,  103.82, 105.74, 107.68, 109.51, 111.45, 
			113.30, 115.24, 117.16, 119.04, 120.96,  122.80, 124.71, 126.59, 128.50, 130.43, 
			132.27, 134.24, 136.03, 138.01, 139.93,  141.79, 143.74, 145.56, 147.52, 149.40, 
		};

		数据表数量=4;
		数据表[0]=数据表1;
		数据表[1]=数据表2;
		数据表[2]=数据表3;
		数据表[3]=数据表4;

		ResId=RID_技能图标_剑帝+樱落斩;
		符文起始ResId=RID_符文图标_剑帝+樱落斩符文*5;
		白金徽章可选=TRUE;
		时装上衣可选=TRUE;
	}

	virtual float 获取伤害(int 等级,int TP等级=0,BOOL 应用护石=FALSE)
	{
		float 基础伤害=(数据表[0])[等级]+(数据表[1])[等级]+(数据表[2])[等级]*8+(数据表[3])[等级];	//1+1+8+1段
		float TP增伤=1.0+TP等级*PC(10);
		return 基础伤害*TP增伤;
	}

	virtual float 获取冷却(BOOL 应用护石=FALSE)
	{
		return 冷却时间;
	}
};

class DNF技能对象_碎岩裂地掌 : public DNF技能对象
{
public:
	virtual void 初始化()
	{
		索引=碎岩裂地掌;
		名称=L"碎岩裂地掌";
		所属职业=职业_流浪武士;
		技能类型=主动技能;
		可用护石=FALSE;
		可用符文=TRUE;
		可用TP=TRUE;

		学习等级=30;
		等级上限=70;
		精通等级=60;
		版本等级=43;
		TP学习等级=55;
		TP等级上限=9;
		TP精通等级=7;

		无色数量=0;
		手搓冷却缩减=PC(1);
		冷却时间=12.0f;

		float 数据表1[技能等级上限]={
			0.0f,
			94.28, 103.79, 113.36, 122.92, 132.49,  142.06, 151.63, 161.18, 170.77, 180.30, 
			189.88, 199.42, 209.01, 218.54, 228.14,  237.65, 247.27, 256.76, 266.43, 275.96, 
			285.49, 295.07, 304.63, 314.19, 323.70,  333.30, 342.81, 352.40, 361.95, 371.56, 
			381.10, 390.69, 400.20, 409.78, 419.31,  428.93, 438.46, 448.05, 457.55, 467.18, 
			476.73, 486.30, 495.85, 505.44, 514.97,  524.53, 534.08, 543.62, 553.21, 562.73, 
			572.38, 581.87, 591.45, 601.04, 610.58,  620.15, 629.71, 639.25, 648.83, 658.36, 
			667.98, 677.52, 687.12, 696.62, 706.20,  715.76, 725.32, 734.88, 744.44, 754.00, 
		};

		数据表数量=1;
		数据表[0]=数据表1;

		ResId=RID_技能图标_剑帝+碎岩裂地掌;
		符文起始ResId=RID_符文图标_剑帝+碎岩裂地掌符文*5;
		白金徽章可选=TRUE;
		时装上衣可选=TRUE;
	}

	virtual float 获取伤害(int 等级,int TP等级=0,BOOL 应用护石=FALSE)
	{
		float 基础伤害=(数据表[0])[等级];
		float TP增伤=1.0+TP等级*PC(10);
		return 基础伤害*TP增伤;
	}

	virtual float 获取冷却(BOOL 应用护石=FALSE)
	{
		return 冷却时间;
	}
};

class DNF技能对象_圆舞斩 : public DNF技能对象
{
public:
	virtual void 初始化()
	{
		索引=圆舞斩;
		名称=L"圆舞斩";
		所属职业=职业_流浪武士;
		技能类型=主动技能;
		可用护石=FALSE;
		可用符文=TRUE;
		可用TP=TRUE;

		学习等级=30;
		等级上限=70;
		精通等级=60;
		版本等级=43;
		TP学习等级=55;
		TP等级上限=9;
		TP精通等级=7;

		无色数量=0;
		手搓冷却缩减=PC(1);
		冷却时间=11.0f;

		float 数据表1[技能等级上限]={
			0.0f,
			44.10, 48.59, 53.06, 57.54, 61.95,  66.44, 70.94, 75.40, 79.90, 84.36, 
			88.86, 93.34, 97.73, 102.24, 106.71,  111.20, 115.67, 120.16, 124.66, 129.12, 
			133.57, 138.01, 142.49, 146.99, 151.44,  155.96, 160.41, 164.89, 169.34, 173.83, 
			178.32, 182.74, 187.23, 191.76, 196.20,  200.67, 205.12, 209.63, 214.09, 218.59, 
			223.08, 227.55, 232.00, 236.42, 240.92,  245.38, 249.88, 254.38, 258.85, 263.32, 
			267.72, 272.21, 276.69, 281.19, 285.66,  290.13, 294.63, 299.12, 303.57, 307.98, 
			312.52, 316.97, 321.42, 325.94, 330.41,  334.88, 339.35, 343.82, 348.29, 352.76, 
		};

		数据表数量=1;
		数据表[0]=数据表1;

		ResId=RID_技能图标_剑帝+圆舞斩;
		符文起始ResId=RID_符文图标_剑帝+圆舞斩符文*5;
		白金徽章可选=TRUE;
		时装上衣可选=TRUE;
	}

	virtual float 获取伤害(int 等级,int TP等级=0,BOOL 应用护石=FALSE)
	{
		float 基础伤害=(数据表[0])[等级]*2;	//2段，抓取和冲击波二选一
		float TP增伤=1.0+TP等级*PC(10);
		return 基础伤害*TP增伤;
	}

	virtual float 获取冷却(BOOL 应用护石=FALSE)
	{
		return 冷却时间;
	}
};

class DNF技能对象_乱花葬 : public DNF技能对象
{
public:
	virtual void 初始化()
	{
		索引=乱花葬;
		名称=L"乱花葬";
		所属职业=职业_流浪武士;
		技能类型=主动技能;
		可用护石=TRUE;
		可用符文=TRUE;
		可用TP=TRUE;

		学习等级=35;
		等级上限=70;
		精通等级=60;
		版本等级=27;
		TP学习等级=55;
		TP等级上限=7;
		TP精通等级=5;

		无色数量=1;
		手搓冷却缩减=PC(2);
		冷却时间=25.0f;

		float 数据表1[技能等级上限]={
			0.0f,
			4.88, 5.66, 6.45, 7.21, 8.01,  8.79, 9.55, 10.34, 11.11, 11.90, 
			12.69, 13.44, 14.23, 15.01, 15.79,  16.59, 17.33, 18.12, 18.90, 19.69, 
			20.47, 21.25, 22.01, 22.81, 23.58,  24.35, 25.15, 25.91, 26.69, 27.47, 
			28.25, 29.04, 29.80, 30.58, 31.37,  32.16, 32.92, 33.70, 34.48, 35.27, 
			36.04, 36.82, 37.59, 38.39, 39.14,  39.94, 40.72, 41.49, 42.28, 43.04, 
			43.82, 44.61, 45.38, 46.17, 46.95,  47.71, 48.50, 49.27, 50.07, 50.86, 
			51.64, 52.42, 53.20, 53.98, 54.76,  55.54, 56.32, 57.10, 57.88, 58.66, 
		};

		float 数据表2[技能等级上限]={
			0.0f,
			48.65, 56.41, 64.16, 71.92, 79.69,  87.43, 95.18, 102.96, 110.70, 118.47, 
			126.20, 133.98, 141.73, 149.47, 157.23,  165.01, 172.76, 180.51, 188.25, 196.02, 
			203.77, 211.53, 219.28, 227.03, 234.81,  242.55, 250.32, 258.07, 265.83, 273.58, 
			281.34, 289.09, 296.84, 304.61, 312.36,  320.13, 327.88, 335.63, 343.40, 351.13, 
			358.90, 366.65, 374.39, 382.18, 389.93,  397.69, 405.45, 413.19, 420.95, 428.70, 
			436.46, 444.22, 451.99, 459.72, 467.51,  475.24, 482.99, 490.76, 498.50, 506.28, 
			514.04, 521.80, 529.56, 537.32, 545.08,  552.84, 560.60, 568.36, 576.12, 583.88, 
		};

		float 数据表3[技能等级上限]={
			0.0f,
			7.87, 9.12, 10.38, 11.62, 12.86,  14.15, 15.39, 16.64, 17.88, 19.16, 
			20.41, 21.66, 22.92, 24.17, 25.43,  26.67, 27.93, 29.19, 30.46, 31.70, 
			32.94, 34.20, 35.45, 36.71, 37.95,  39.23, 40.49, 41.72, 42.99, 44.22, 
			45.48, 46.74, 48.01, 49.26, 50.52,  51.77, 53.00, 54.27, 55.51, 56.79, 
			58.05, 59.30, 60.55, 61.77, 63.05,  64.29, 65.57, 66.81, 68.08, 69.34, 
			70.58, 71.81, 73.06, 74.35, 75.59,  76.85, 78.10, 79.37, 80.60, 81.85, 
			83.10, 84.35, 85.60, 86.85, 88.10,  89.35, 90.60, 91.85, 93.10, 94.35, 
		};

		float 数据表4[技能等级上限]={
			0.0f,
			77.51, 89.87, 102.22, 114.59, 126.93,  139.30, 151.63, 164.01, 176.35, 188.71, 
			201.07, 213.42, 225.79, 238.16, 250.50,  262.86, 275.22, 287.58, 299.93, 312.29, 
			324.65, 336.97, 349.35, 361.70, 374.07,  386.42, 398.80, 411.13, 423.50, 435.86, 
			448.20, 460.57, 472.92, 485.27, 497.64,  510.00, 522.36, 534.71, 547.08, 559.41, 
			571.76, 584.14, 596.47, 608.86, 621.21,  633.57, 645.91, 658.27, 670.64, 682.98, 
			695.35, 707.71, 720.05, 732.43, 744.77,  757.13, 769.48, 781.83, 794.20, 806.55, 
			818.91, 831.27, 843.63, 855.99, 868.35,  880.71, 893.07, 905.43, 917.79, 930.15, 
		};

		数据表数量=4;
		数据表[0]=数据表1;
		数据表[1]=数据表2;
		数据表[2]=数据表3;
		数据表[3]=数据表4;

		ResId=RID_技能图标_剑帝+乱花葬;
		符文起始ResId=RID_符文图标_剑帝+乱花葬符文*5;
		白金徽章可选=TRUE;
		时装上衣可选=TRUE;
	}

	virtual float 获取伤害(int 等级,int TP等级=0,BOOL 应用护石=FALSE)
	{
		if (应用护石)
		{
			float 基础伤害=(数据表[0])[等级]*10+(数据表[1])[等级]+(数据表[2])[等级]*9+(数据表[3])[等级];	//6*1.67+1+5*1.8+1段
			基础伤害*=1.07f;
			float TP增伤=1.0+TP等级*PC(10);
			return 基础伤害*TP增伤;
		}
		else
		{
			float 基础伤害=(数据表[0])[等级]*6+(数据表[1])[等级]+(数据表[2])[等级]*5+(数据表[3])[等级];		//6+1+5+1段
			float TP增伤=1.0+TP等级*PC(10);
			return 基础伤害*TP增伤;
		}
	}

	virtual float 获取冷却(BOOL 应用护石=FALSE)
	{
		return 冷却时间;
	}
};

class DNF技能对象_游龙掌 : public DNF技能对象
{
public:
	virtual void 初始化()
	{
		索引=游龙掌;
		名称=L"游龙掌";
		所属职业=职业_流浪武士;
		技能类型=主动技能;
		可用护石=FALSE;
		可用符文=TRUE;
		可用TP=TRUE;

		学习等级=35;
		等级上限=70;
		精通等级=60;
		版本等级=41;
		TP学习等级=55;
		TP等级上限=7;
		TP精通等级=5;

		无色数量=0;
		手搓冷却缩减=PC(2);
		冷却时间=12.0f;

		float 数据表1[技能等级上限]={
			0.0f,
			12.54, 13.86, 15.20, 16.39, 17.70,  19.03, 20.36, 21.59, 22.92, 24.26, 
			25.53, 26.74, 28.05, 29.41, 30.69,  31.99, 33.32, 34.57, 35.89, 37.18, 
			38.50, 39.76, 41.07, 42.44, 43.69,  44.91, 46.26, 47.58, 48.85, 50.16, 
			51.52, 52.74, 54.03, 55.34, 56.68,  57.93, 59.20, 60.59, 61.86, 63.08, 
			64.39, 65.69, 67.02, 68.34, 69.57,  70.92, 72.21, 73.52, 74.73, 76.10, 
			77.36, 78.71, 80.03, 81.27, 82.57,  83.86, 85.19, 86.48, 87.74, 89.01, 
			90.37, 91.66, 92.90, 94.25, 95.53,  96.82, 98.06, 99.42, 100.76, 102.02, 
		};

		数据表数量=1;
		数据表[0]=数据表1;

		ResId=RID_技能图标_剑帝+游龙掌;
		符文起始ResId=RID_符文图标_剑帝+游龙掌符文*5;
		白金徽章可选=TRUE;
		时装上衣可选=TRUE;
	}

	virtual float 获取伤害(int 等级,int TP等级=0,BOOL 应用护石=FALSE)
	{
		float 基础伤害=(数据表[0])[等级]*10;	//10段
		float TP增伤=1.0+TP等级*PC(10);
		return 基础伤害*TP增伤;
	}

	virtual float 获取冷却(BOOL 应用护石=FALSE)
	{
		return 冷却时间;
	}
};

class DNF技能对象_湮烈掌 : public DNF技能对象
{
public:
	virtual void 初始化()
	{
		索引=湮烈掌;
		名称=L"湮烈掌";
		所属职业=职业_流浪武士;
		技能类型=主动技能;
		可用护石=TRUE;
		可用符文=TRUE;
		可用TP=TRUE;

		学习等级=40;
		等级上限=70;
		精通等级=60;
		版本等级=38;
		TP学习等级=55;
		TP等级上限=7;
		TP精通等级=5;

		无色数量=1;
		手搓冷却缩减=PC(2);
		冷却时间=30.0f;

		//爆炸
		float 数据表1[技能等级上限]={
			0.0f,
			24.21, 26.65, 29.12, 31.58, 34.03,  36.52, 38.96, 41.43, 43.87, 46.31, 
			48.77, 51.25, 53.70, 56.17, 58.62,  61.07, 63.53, 66.00, 68.44, 70.89, 
			73.36, 75.81, 78.26, 80.73, 83.18,  85.62, 88.09, 90.54, 93.01, 95.49, 
			97.95, 100.39, 102.85, 105.29, 107.77,  110.22, 112.67, 115.12, 117.60, 120.04, 
			122.50, 124.96, 127.40, 129.86, 132.31,  134.77, 137.24, 139.69, 142.15, 144.60, 
			147.04, 149.51, 151.98, 154.43, 156.90,  159.34, 161.80, 164.26, 166.74, 169.17, 
			171.64, 174.09, 176.55, 178.99, 181.46,  183.93, 186.39, 188.82, 191.28, 193.74, 
		};

		//发射
		float 数据表2[技能等级上限]={
			0.0f,
			169.51, 186.73, 203.95, 221.12, 238.31,  255.53, 272.72, 289.91, 307.12, 324.33, 
			341.52, 358.70, 375.89, 393.12, 410.31,  427.51, 444.70, 461.90, 479.12, 496.29, 
			513.48, 530.71, 547.89, 565.10, 582.29,  599.51, 616.69, 633.88, 651.11, 668.30, 
			685.48, 702.67, 719.89, 737.09, 754.28,  771.47, 788.68, 805.88, 823.05, 840.29, 
			857.47, 874.69, 891.86, 909.05, 926.30,  943.48, 960.67, 977.86, 995.06, 1012.26, 
			1029.46, 1046.68, 1063.86, 1081.05, 1098.24,  1115.46, 1132.66, 1149.85, 1167.03, 1184.25, 
			1201.46, 1218.65, 1235.86, 1253.04, 1270.24,  1287.45, 1304.64, 1321.84, 1339.01, 1356.24, 
		};

		数据表数量=2;
		数据表[0]=数据表1;
		数据表[1]=数据表2;

		ResId=RID_技能图标_剑帝+湮烈掌;
		符文起始ResId=RID_符文图标_剑帝+湮烈掌符文*5;
		白金徽章可选=TRUE;
		时装上衣可选=TRUE;
	}

	virtual float 获取伤害(int 等级,int TP等级=0,BOOL 应用护石=FALSE)
	{
		if (应用护石)
		{
			float 基础伤害1=(数据表[0])[等级];
			float 基础伤害2=(数据表[1])[等级];
			基础伤害1*=1.0f+PC(311);
			基础伤害2*=1.0f+PC(27);
			float TP增伤=1.0+TP等级*PC(10);
			return (基础伤害1+基础伤害2)*TP增伤;
		}
		else
		{
			float 基础伤害=(数据表[0])[等级]*3+(数据表[1])[等级];		//1+3段
			float TP增伤=1.0+TP等级*PC(10);
			return 基础伤害*TP增伤;
		}
	}

	virtual float 获取冷却(BOOL 应用护石=FALSE)
	{
		return 冷却时间;
	}
};

class DNF技能对象_回天璇鸣剑 : public DNF技能对象
{
public:
	virtual void 初始化()
	{
		索引=回天璇鸣剑;
		名称=L"回天璇鸣剑";
		所属职业=职业_流浪武士;
		技能类型=主动技能;
		可用护石=FALSE;
		可用符文=TRUE;
		可用TP=TRUE;

		学习等级=40;
		等级上限=70;
		精通等级=60;
		版本等级=38;
		TP学习等级=55;
		TP等级上限=7;
		TP精通等级=5;

		无色数量=1;
		手搓冷却缩减=PC(2);
		冷却时间=20.0f;

		//10段合并
		float 数据表1[技能等级上限]={
			0.0f,
			48.59, 53.26, 58.61, 63.58, 68.26,  72.89, 78.26, 82.91, 87.88, 92.90, 
			97.93, 102.55, 107.21, 112.59, 117.57,  122.21, 127.58, 132.24, 136.90, 142.20, 
			146.88, 151.88, 156.51, 161.89, 166.49,  171.52, 176.53, 181.53, 186.18, 190.85, 
			196.17, 200.82, 205.81, 211.20, 215.85,  220.46, 225.14, 230.51, 235.49, 240.13, 
			245.48, 250.12, 254.80, 259.80, 264.81,  269.80, 274.44, 279.80, 284.45, 289.47, 
			294.48, 299.43, 304.09, 309.45, 314.11,  318.76, 324.09, 329.09, 333.77, 339.13, 
			343.79, 348.42, 353.78, 358.42, 363.40,  368.79, 373.45, 378.07, 383.44, 388.08, 
		};

		//爆炸
		float 数据表2[技能等级上限]={
			0.0f,
			141.58, 155.93, 170.33, 184.70, 199.02,  213.41, 227.73, 242.12, 256.51, 270.83, 
			285.15, 299.58, 313.88, 328.27, 342.66,  356.98, 371.39, 385.72, 400.09, 414.48, 
			428.79, 443.19, 457.49, 471.90, 486.34,  500.66, 514.96, 529.35, 543.64, 558.06, 
			572.40, 586.79, 601.16, 615.48, 629.87,  644.21, 658.58, 673.00, 687.30, 701.72, 
			716.01, 730.43, 744.81, 759.14, 773.46,  787.88, 802.17, 816.55, 830.95, 845.29, 
			859.69, 873.97, 888.39, 902.80, 917.10,  931.45, 945.82, 960.23, 974.57, 988.94, 
			1003.29, 1017.65, 1031.95, 1046.37, 1060.69,  1075.06, 1089.46, 1103.78, 1118.20, 1132.50, 
		};

		//单段
		float 数据表3[技能等级上限]={
			0.0f,
			4.84, 5.31, 5.88, 6.39, 6.82,  7.30, 7.85, 8.27, 8.79, 9.29, 
			9.79, 10.25, 10.75, 11.26, 11.77,  12.22, 12.76, 13.22, 13.69, 14.23, 
			14.69, 15.20, 15.64, 16.16, 16.66,  17.14, 17.64, 18.14, 18.63, 19.08, 
			19.61, 20.09, 20.60, 21.10, 21.58,  22.07, 22.53, 23.06, 23.55, 24.02, 
			24.54, 25.03, 25.49, 26.00, 26.47,  27.00, 27.46, 27.99, 28.46, 28.97, 
			29.44, 29.95, 30.44, 30.96, 31.39,  31.91, 32.43, 32.92, 33.37, 33.91, 
			34.38, 34.84, 35.37, 35.85, 36.34,  36.88, 37.36, 37.82, 38.36, 38.83, 
		};

		数据表数量=3;
		数据表[0]=数据表1;
		数据表[1]=数据表2;
		数据表[2]=数据表3;

		ResId=RID_技能图标_剑帝+回天璇鸣剑;
		符文起始ResId=RID_符文图标_剑帝+回天璇鸣剑符文*5;
		白金徽章可选=TRUE;
		时装上衣可选=TRUE;
	}

	virtual float 获取伤害(int 等级,int TP等级=0,BOOL 应用护石=FALSE)
	{
		//技能描述是10段，修炼场实测只能打8段
		//如果连按直接释放，可以将10段合并成1段（数据表1），所以仍采用10段数据
		float 基础伤害=(数据表[3])[等级]*10+(数据表[2])[等级];		//10+1段
		float TP增伤=1.0+TP等级*PC(10);
		return 基础伤害*TP增伤;
	}

	virtual float 获取冷却(BOOL 应用护石=FALSE)
	{
		return 冷却时间;
	}
};

class DNF技能对象_花舞千魂 : public DNF技能对象
{
public:
	virtual void 初始化()
	{
		索引=花舞千魂;
		名称=L"花舞千魂";
		所属职业=职业_流浪武士;
		技能类型=主动技能;
		可用护石=TRUE;
		可用符文=TRUE;
		可用TP=TRUE;

		学习等级=45;
		等级上限=70;
		精通等级=60;
		版本等级=36;
		TP学习等级=55;
		TP等级上限=7;
		TP精通等级=5;

		无色数量=2;
		手搓冷却缩减=PC(2);
		冷却时间=40.0f;

		//一闪
		float 数据表1[技能等级上限]={
			0.0f,
			167.31, 184.82, 201.36, 218.89, 236.74,  253.65, 271.44, 288.26, 305.67, 323.06, 
			340.05, 357.73, 374.77, 392.45, 409.98,  426.67, 444.28, 461.21, 478.57, 496.24, 
			513.27, 530.69, 548.16, 565.33, 582.64,  600.17, 617.42, 634.93, 651.58, 669.01, 
			686.49, 703.36, 721.09, 738.02, 755.56,  772.94, 790.09, 807.83, 824.95, 842.18, 
			859.67, 876.54, 893.90, 911.26, 928.44,  945.88, 963.43, 980.29, 997.83, 1015.04, 
			1033.61, 1051.11, 1068.54, 1086.02, 1103.16,  1120.34, 1138.09, 1155.39, 1172.40, 1189.91, 
			1207.27, 1224.50, 1242.17, 1259.45, 1276.64,  1293.99, 1311.70, 1329.10, 1346.23, 1363.93, 
		};

		float 数据表2[技能等级上限]={
			0.0f,
			22.99, 25.40, 27.76, 30.14, 32.59,  34.97, 37.38, 39.68, 42.09, 44.53, 
			46.81, 49.24, 51.59, 54.01, 56.44,  58.76, 61.18, 63.49, 65.86, 68.29, 
			70.63, 73.01, 75.45, 77.88, 80.20,  82.63, 84.97, 87.43, 89.69, 92.12, 
			94.50, 96.81, 99.27, 101.56, 104.00,  106.35, 108.76, 111.16, 113.58, 115.94, 
			118.34, 120.66, 123.10, 125.49, 127.82,  130.24, 132.61, 134.96, 137.37, 139.74, 
			142.33, 144.74, 147.08, 149.48, 151.90,  154.24, 156.66, 159.04, 161.36, 163.80, 
			166.24, 168.55, 171.01, 173.43, 175.73,  178.13, 180.58, 182.92, 185.27, 187.77, 
		};

		float 数据表3[技能等级上限]={
			0.0f,
			92.01, 101.68, 110.91, 120.58, 130.24,  139.74, 149.36, 158.75, 168.39, 177.89, 
			187.30, 196.96, 206.43, 216.07, 225.74,  234.99, 244.65, 253.98, 263.50, 273.14, 
			282.53, 292.02, 301.72, 311.35, 320.65,  330.35, 339.86, 349.55, 358.70, 368.43, 
			378.04, 387.29, 396.94, 406.30, 415.95,  425.43, 435.12, 444.78, 454.16, 463.63, 
			473.28, 482.65, 492.17, 501.84, 511.24,  520.82, 530.49, 539.75, 549.39, 558.90, 
			569.09, 578.74, 588.23, 597.84, 607.49,  616.88, 626.52, 636.19, 645.45, 655.06, 
			664.72, 674.24, 683.90, 693.48, 702.91,  712.56, 722.19, 731.72, 741.09, 750.97, 
		};

		数据表数量=3;
		数据表[0]=数据表1;
		数据表[1]=数据表2;
		数据表[2]=数据表3;

		ResId=RID_技能图标_剑帝+花舞千魂;
		符文起始ResId=RID_符文图标_剑帝+花舞千魂符文*5;
		白金徽章可选=TRUE;
		时装上衣可选=TRUE;
	}

	virtual float 获取伤害(int 等级,int TP等级=0,BOOL 应用护石=FALSE)
	{
		if (应用护石)
		{
			float 基础伤害=(数据表[0])[等级];
			基础伤害*=1.0f+PC(100)+PC(33);
			float TP增伤=1.0+TP等级*PC(10);
			return 基础伤害*TP增伤;
		}
		else
		{
			float 基础伤害=(数据表[0])[等级]+(数据表[1])[等级]*2+(数据表[2])[等级];		//1+2+1段
			float TP增伤=1.0+TP等级*PC(10);
			return 基础伤害*TP增伤;
		}
	}

	virtual float 获取冷却(BOOL 应用护石=FALSE)
	{
		return 冷却时间;
	}
};


class DNF技能对象_花开寒影 : public DNF技能对象
{
public:
	virtual void 初始化()
	{
		索引=花开寒影;
		名称=L"花开寒影";
		所属职业=职业_流浪武士;
		技能类型=觉醒技能;
		可用护石=FALSE;
		可用符文=FALSE;
		可用TP=FALSE;

		学习等级=50;
		等级上限=50;
		精通等级=40;
		版本等级=14;
		TP学习等级=55;
		TP等级上限=7;
		TP精通等级=5;

		无色数量=5;
		手搓冷却缩减=PC(5);
		冷却时间=145.0f;

		float 数据表1[技能等级上限]={
			0.0f,
			105.11, 129.48, 153.85, 178.22, 202.59,  226.96, 251.33, 275.70, 300.07, 324.44, 
			348.81, 373.18, 397.55, 421.92, 446.29,  470.67, 495.01, 519.40, 543.75, 568.15, 
			592.49, 616.86, 641.23, 665.65, 690.00,  714.38, 738.72, 763.12, 787.50, 811.86, 
			836.23, 860.57, 884.95, 909.35, 933.70,  958.07, 982.43, 1006.80, 1031.20, 1055.55, 
			1079.92, 1104.29, 1128.66, 1153.03, 1177.40,  1201.77, 1226.14, 1250.51, 1274.88, 1299.25, 
		};

		float 数据表2[技能等级上限]={
			0.0f,
			16.15, 19.90, 23.65, 27.40, 31.15,  34.90, 38.65, 42.40, 46.15, 49.90, 
			53.65, 57.40, 61.15, 64.90, 68.66,  72.40, 76.14, 79.91, 83.65, 87.40, 
			91.14, 94.92, 98.65, 102.41, 106.16,  109.89, 113.66, 117.39, 121.15, 124.88, 
			128.66, 132.37, 136.14, 139.90, 143.64,  147.37, 151.15, 154.89, 158.61, 162.41, 
			166.16, 169.91, 173.66, 177.41, 181.16,  184.91, 188.66, 192.41, 196.16, 199.91, 
		};

		float 数据表3[技能等级上限]={
			0.0f,
			735.62, 906.22, 1076.82, 1247.42, 1418.02,  1588.62, 1759.22, 1929.82, 2100.42, 2271.02, 
			2441.62, 2612.22, 2782.82, 2953.42, 3124.04,  3294.60, 3465.23, 3635.79, 3806.40, 3977.03, 
			4147.59, 4318.20, 4488.76, 4659.38, 4830.00,  5000.56, 5171.20, 5341.77, 5512.35, 5682.98, 
			5853.54, 6024.16, 6194.74, 6365.33, 6535.96,  6706.52, 6877.14, 7047.72, 7218.30, 7388.94, 
			7559.54, 7730.14, 7900.74, 8071.34, 8241.94,  8412.54, 8583.14, 8753.74, 8924.34, 9094.94, 
		};

		数据表数量=3;
		数据表[0]=数据表1;
		数据表[1]=数据表2;
		数据表[2]=数据表3;

		ResId=RID_技能图标_剑帝+花开寒影;
		
		白金徽章可选=FALSE;
		时装上衣可选=TRUE;
	}

	virtual float 获取伤害(int 等级,int TP等级=0,BOOL 应用护石=FALSE)
	{
		//3级以上会+15%物理暴击
		int 段数=10;
		if (等级>=6)
			段数+=3;
		float 基础伤害1=(数据表[0])[等级]+(数据表[1])[等级]*段数;
		float 基础伤害2=(数据表[2])[等级];
		if (等级>=9)
			基础伤害2*=1.1f;
		return 基础伤害1+基础伤害2;
	}

	virtual float 获取冷却(BOOL 应用护石=FALSE)
	{
		return 冷却时间;
	}
};

class DNF技能对象_啸空十字刃 : public DNF技能对象
{
public:
	virtual void 初始化()
	{
		索引=啸空十字刃;
		名称=L"啸空十字刃";
		所属职业=职业_流浪武士;
		技能类型=主动技能;
		可用护石=TRUE;
		可用符文=TRUE;
		可用TP=TRUE;

		学习等级=60;
		等级上限=50;
		精通等级=40;
		版本等级=28;
		TP学习等级=60;
		TP等级上限=7;
		TP精通等级=5;

		无色数量=1;
		手搓冷却缩减=PC(2);
		冷却时间=30.0f;

		//水平
		float 数据表1[技能等级上限]={
			0.0f,
			80.35, 88.50, 96.65, 104.78, 112.94,  121.09, 129.24, 137.39, 145.55, 153.71, 
			161.83, 169.99, 178.13, 186.29, 194.41,  202.56, 210.75, 218.87, 227.03, 235.17, 
			243.34, 251.43, 259.60, 267.76, 275.91,  284.05, 292.21, 300.36, 308.52, 316.64, 
			324.82, 332.98, 341.12, 349.27, 357.41,  365.59, 373.72, 381.86, 390.02, 398.16, 
			406.32, 414.46, 422.60, 430.75, 438.91,  447.05, 455.21, 463.37, 471.52, 479.69, 

		};

		//垂直
		float 数据表2[技能等级上限]={
			0.0f,
			93.73, 103.23, 112.74, 122.24, 131.74,  141.27, 150.78, 160.25, 169.78, 179.29, 
			188.80, 198.32, 207.83, 217.34, 226.82,  236.33, 245.86, 255.35, 264.86, 274.40, 
			283.88, 293.39, 302.90, 312.41, 321.93,  331.44, 340.92, 350.45, 359.95, 369.47, 
			378.96, 388.48, 397.97, 407.50, 416.99,  426.48, 436.02, 445.53, 455.03, 464.53, 
			474.03, 483.55, 493.06, 502.58, 512.07,  521.56, 531.08, 540.61, 550.12, 559.63, 
		};

		//爆炸
		float 数据表3[技能等级上限]={
			0.0f,
			107.13, 117.98, 128.85, 139.70, 150.59,  161.43, 172.32, 183.20, 194.07, 204.91, 
			215.80, 226.63, 237.50, 248.38, 259.25,  270.11, 280.97, 291.85, 302.72, 313.58, 
			324.45, 335.34, 346.18, 357.05, 367.92,  378.78, 389.67, 400.53, 411.39, 422.23, 
			433.12, 444.00, 454.84, 465.70, 476.60,  487.44, 498.33, 509.18, 520.05, 530.91, 
			541.78, 552.66, 563.52, 574.38, 585.27,  596.10, 606.99, 617.87, 628.68, 639.59, 
		};

		数据表数量=3;
		数据表[0]=数据表1;
		数据表[1]=数据表2;
		数据表[2]=数据表3;

		ResId=RID_技能图标_剑帝+啸空十字刃;
		符文起始ResId=RID_符文图标_剑帝+啸空十字刃符文*5;
		白金徽章可选=TRUE;
		时装上衣可选=TRUE;
	}

	virtual float 获取伤害(int 等级,int TP等级=0,BOOL 应用护石=FALSE)
	{
		if (应用护石)
		{
			float 基础伤害1=(数据表[0])[等级];
			float 基础伤害2=(数据表[2])[等级];
			基础伤害2*=1.88f;
			基础伤害1*=1.09;
			基础伤害2*=1.09;
			float TP增伤=1.0+TP等级*PC(10);
			return (基础伤害1+基础伤害2)*TP增伤;
		}
		else
		{
			float 基础伤害=(数据表[0])[等级]+(数据表[1])[等级]+(数据表[2])[等级];
			float TP增伤=1.0+TP等级*PC(10);
			return 基础伤害*TP增伤;
		}
	}

	virtual float 获取冷却(BOOL 应用护石=FALSE)
	{
		if (应用护石)
			return 冷却时间*(1.0f-PC(20));
		return 冷却时间;
	}
};

class DNF技能对象_如来神掌 : public DNF技能对象
{
public:
	virtual void 初始化()
	{
		索引=如来神掌;
		名称=L"如来神掌";
		所属职业=职业_流浪武士;
		技能类型=主动技能;
		可用护石=TRUE;
		可用符文=TRUE;
		可用TP=TRUE;

		学习等级=70;
		等级上限=50;
		精通等级=40;
		版本等级=23;
		TP学习等级=70;
		TP等级上限=7;
		TP精通等级=5;

		无色数量=2;
		手搓冷却缩减=PC(2);
		冷却时间=50.0f;

		float 数据表1[技能等级上限]={
			0.0f,
			208.28, 229.41, 250.58, 271.69, 292.81,  313.93, 335.10, 356.19, 377.35, 398.51, 
			419.58, 440.73, 461.83, 483.00, 504.15,  525.25, 546.42, 567.48, 588.65, 609.80, 
			630.92, 652.03, 673.14, 694.34, 715.49,  736.57, 757.72, 778.82, 799.98, 821.05, 
			842.23, 863.38, 884.49, 905.65, 926.76,  947.87, 968.97, 990.16, 1011.28, 1032.39, 
			1053.55, 1074.69, 1095.78, 1116.90, 1138.08,  1159.19, 1180.29, 1201.46, 1222.58, 1243.72, 
		};

		float 数据表2[技能等级上限]={
			0.0f,
			312.45, 344.13, 375.85, 407.54, 439.25,  470.86, 502.58, 534.26, 565.99, 597.67, 
			629.39, 661.06, 692.79, 724.49, 756.13,  787.86, 819.56, 851.27, 882.94, 914.67, 
			946.34, 978.07, 1009.68, 1041.41, 1073.10,  1104.82, 1136.48, 1168.21, 1199.89, 1231.62, 
			1263.33, 1294.97, 1326.69, 1358.36, 1390.08,  1421.76, 1453.50, 1485.17, 1516.90, 1548.50, 
			1580.23, 1611.90, 1643.61, 1675.30, 1707.04,  1738.73, 1770.45, 1802.12, 1833.77, 1865.48, 
		};


		数据表数量=2;
		数据表[0]=数据表1;
		数据表[1]=数据表2;

		ResId=RID_技能图标_剑帝+如来神掌;
		符文起始ResId=RID_符文图标_剑帝+如来神掌符文*5;
		白金徽章可选=TRUE;
		时装上衣可选=TRUE;
	}

	virtual float 获取伤害(int 等级,int TP等级=0,BOOL 应用护石=FALSE)
	{
		if (应用护石)
		{
			float 基础伤害=(数据表[0])[等级];
			基础伤害*=1.0f+PC(171)+PC(45);
			float TP增伤=1.0+TP等级*PC(10);
			return 基础伤害*TP增伤;
		}
		else
		{
			float 基础伤害=(数据表[0])[等级]+(数据表[1])[等级];
			float TP增伤=1.0+TP等级*PC(10);
			return 基础伤害*TP增伤;
		}
	}

	virtual float 获取冷却(BOOL 应用护石=FALSE)
	{
		return 冷却时间;
	}
};

class DNF技能对象_莲花剑舞 : public DNF技能对象
{
public:
	virtual void 初始化()
	{
		索引=莲花剑舞;
		名称=L"莲花剑舞";
		所属职业=职业_流浪武士;
		技能类型=主动技能;
		可用护石=TRUE;
		可用符文=TRUE;
		可用TP=FALSE;

		学习等级=75;
		等级上限=50;
		精通等级=40;
		版本等级=21;

		无色数量=3;
		手搓冷却缩减=PC(5);
		冷却时间=40.0f;

		//前斩
		float 数据表1[技能等级上限]={
			0.0f,
			41.72, 45.95, 50.20, 54.44, 58.66,  62.90, 67.11, 71.37, 75.58, 79.81, 
			84.06, 88.30, 92.49, 96.76, 100.98,  105.23, 109.48, 113.71, 117.90, 122.15, 
			126.37, 130.58, 134.89, 139.11, 143.31,  147.53, 151.77, 155.99, 160.23, 164.51, 
			168.71, 172.93, 177.20, 181.38, 185.64,  189.86, 194.12, 198.33, 202.60, 206.81, 
			211.03, 215.24, 219.53, 223.75, 227.97,  232.23, 236.43, 240.66, 244.90, 249.19, 
		};

		//空斩/后斩
		float 数据表2[技能等级上限]={
			0.0f,
			62.59, 68.93, 75.28, 81.63, 87.97,  94.34, 100.68, 107.03, 113.37, 119.71, 
			126.08, 132.43, 138.80, 145.11, 151.48,  157.83, 164.16, 170.51, 176.88, 183.23, 
			189.55, 195.89, 202.30, 208.64, 214.95,  221.33, 227.70, 234.00, 240.39, 246.72, 
			253.09, 259.37, 265.74, 272.08, 278.42,  284.80, 291.14, 297.50, 303.83, 310.18, 
			316.59, 322.91, 329.23, 335.60, 341.98,  348.27, 354.64, 361.02, 367.37, 373.67, 
		};

		//回旋斩
		float 数据表3[技能等级上限]={
			0.0f,
			250.33, 275.76, 301.15, 326.58, 351.95,  377.33, 402.73, 428.11, 453.53, 478.92, 
			504.31, 529.70, 555.10, 580.50, 605.89,  631.32, 656.67, 682.07, 707.44, 732.92, 
			758.31, 783.63, 809.05, 834.50, 859.87,  885.24, 910.63, 936.06, 961.42, 986.82, 
			1012.21, 1037.64, 1063.02, 1088.43, 1113.81,  1139.20, 1164.60, 1190.01, 1215.38, 1240.78, 
			1266.18, 1291.63, 1317.00, 1342.36, 1367.80,  1393.13, 1418.54, 1443.97, 1469.38, 1494.77, 
		};

		//前斩和回旋斩合并
		float 数据表4[技能等级上限]={
			0.0f,
			292.07, 321.69, 351.33, 381.00, 410.60,  440.23, 469.84, 499.45, 529.10, 558.71, 
			588.37, 617.95, 647.61, 677.23, 706.87,  736.52, 766.16, 795.75, 825.38, 855.03, 
			884.69, 914.26, 943.95, 973.60, 1003.19,  1032.77, 1062.40, 1092.06, 1121.65, 1151.32, 
			1180.94, 1210.58, 1240.25, 1269.82, 1299.42,  1329.07, 1358.74, 1388.32, 1417.97, 1447.59, 
			1477.23, 1506.84, 1536.53, 1566.10, 1595.74,  1625.38, 1654.97, 1684.63, 1714.28, 1743.92, 
		};

		数据表数量=4;
		数据表[0]=数据表1;
		数据表[1]=数据表2;
		数据表[2]=数据表3;
		数据表[3]=数据表4;

		ResId=RID_技能图标_剑帝+莲花剑舞;
		符文起始ResId=RID_符文图标_剑帝+莲花剑舞符文*5;
		白金徽章可选=FALSE;
		时装上衣可选=TRUE;
	}

	virtual float 获取伤害(int 等级,int TP等级=0,BOOL 应用护石=FALSE)
	{
		if (应用护石)
		{
			float 基础伤害=(数据表[1])[等级]*4+(数据表[3])[等级]*2;	//2+2+2段，和跳跃时一样
			基础伤害*=1.0f+PC(11)+PC(22);
			return 基础伤害;
		}
		else
		{
			float 基础伤害=(数据表[0])[等级]*2+(数据表[1])[等级]*4+(数据表[2])[等级]*2;	//2+2+2+2段
			return 基础伤害;
		}
	}

	virtual float 获取冷却(BOOL 应用护石=FALSE)
	{
		return 冷却时间;
	}
};

class DNF技能对象_樱花劫 : public DNF技能对象
{
public:
	virtual void 初始化()
	{
		索引=樱花劫;
		名称=L"樱花劫";
		所属职业=职业_流浪武士;
		技能类型=主动技能;
		可用护石=TRUE;
		可用符文=TRUE;
		可用TP=FALSE;

		学习等级=80;
		等级上限=50;
		精通等级=40;
		版本等级=18;

		无色数量=5;
		手搓冷却缩减=PC(5);
		冷却时间=45.0f;

		float 数据表1[技能等级上限]={
			0.0f,
			1006.72, 1108.83, 1210.90, 1313.06, 1415.18,  1517.33, 1619.45, 1721.60, 1823.70, 1925.88, 
			2027.97, 2130.14, 2232.23, 2334.34, 2436.48,  2538.63, 2640.74, 2742.91, 2844.99, 2947.16, 
			3049.29, 3151.42, 3253.57, 3355.68, 3457.77,  3559.92, 3662.03, 3764.21, 3866.29, 3968.46, 
			4070.56, 4172.73, 4274.84, 4376.99, 4479.07,  4581.21, 4683.32, 4785.47, 4887.60, 4989.72, 
			5091.86, 5194.00, 5296.13, 5398.27, 5500.36,  5602.49, 5704.62, 5806.75, 5908.88, 6011.01, 
		};

		数据表数量=1;
		数据表[0]=数据表1;

		ResId=RID_技能图标_剑帝+樱花劫;
		符文起始ResId=RID_符文图标_剑帝+樱花劫符文*5;
		白金徽章可选=FALSE;
		时装上衣可选=TRUE;
	}

	virtual float 获取伤害(int 等级,int TP等级=0,BOOL 应用护石=FALSE)
	{
		if (应用护石)
		{
			float 基础伤害=(数据表[0])[等级];
			基础伤害*=1.0f+PC(16)+PC(14);
			return 基础伤害;
		}
		else
		{
			float 基础伤害=(数据表[0])[等级];
			return 基础伤害;
		}
	}

	virtual float 获取冷却(BOOL 应用护石=FALSE)
	{
		if (应用护石)
			return 冷却时间*(1.0f-PC(10));
		return 冷却时间;
	}
};

class DNF技能对象_飞花逐月 : public DNF技能对象
{
public:
	virtual void 初始化()
	{
		索引=飞花逐月;
		名称=L"飞花逐月";
		所属职业=职业_流浪武士;
		技能类型=觉醒技能;
		可用护石=FALSE;
		可用符文=FALSE;
		可用TP=FALSE;

		学习等级=85;
		等级上限=50;
		精通等级=40;
		版本等级=7;

		无色数量=10;
		手搓冷却缩减=PC(5);
		冷却时间=180.0f;

		float 数据表1[技能等级上限]={
			0.0f,
			53.67, 66.09, 78.51, 90.93, 103.35,  115.77, 128.19, 140.55, 153.02, 165.44, 
			177.88, 190.27, 202.71, 215.15, 227.57,  239.98, 252.44, 264.82, 277.24, 289.70, 
			302.10, 314.57, 326.99, 339.35, 351.83,  364.26, 376.66, 389.11, 401.53, 413.94, 
			426.38, 438.80, 451.22, 463.64, 476.06,  488.48, 500.90, 513.32, 525.74, 538.16, 
			550.58, 563.00, 575.42, 587.84, 600.26,  612.68, 625.10, 637.52, 649.94, 662.36, 
		};

		float 数据表2[技能等级上限]={
			0.0f,
			1125.35, 1386.30, 1647.25, 1908.20, 2169.15,  2430.10, 2691.05, 2951.98, 3212.89, 3473.84, 
			3734.83, 3995.75, 4256.69, 4517.65, 4778.63,  5039.59, 5300.48, 5561.47, 5822.37, 6083.36, 
			6344.30, 6605.24, 6866.17, 7127.13, 7388.10,  7649.03, 7909.99, 8170.94, 8431.85, 8692.85, 
			8953.76, 9214.71, 9475.66, 9736.61, 9997.56,  10258.51, 10519.46, 10780.41, 11041.36, 11302.31, 
			11563.26, 11824.21, 12085.16, 12346.11, 12607.06,  12868.01, 13128.96, 13389.91, 13650.86, 13911.81, 
		};

		数据表数量=2;
		数据表[0]=数据表1;
		数据表[1]=数据表2;

		ResId=RID_技能图标_剑帝+飞花逐月;
		
		白金徽章可选=FALSE;
		时装上衣可选=TRUE;
	}

	virtual float 获取伤害(int 等级,int TP等级=0,BOOL 应用护石=FALSE)
	{
		//最后一击间隔较长，没计入连击，但伤害是23段+1段
		float 基础伤害=(数据表[0])[等级]*23+(数据表[1])[等级];	//1+18+1+1+1+1+1段
		return 基础伤害;
	}

	virtual float 获取冷却(BOOL 应用护石=FALSE)
	{
		return 冷却时间;
	}
};

class DNF技能对象_落英惊鸿掌 : public DNF技能对象
{
public:
	virtual void 初始化()
	{
		索引=落英惊鸿掌;
		名称=L"落英惊鸿掌";
		所属职业=职业_流浪武士;
		技能类型=主动技能;
		可用护石=FALSE;
		可用符文=FALSE;
		可用TP=FALSE;

		学习等级=95;
		等级上限=50;
		精通等级=40;
		版本等级=11;

		无色数量=7;
		手搓冷却缩减=PC(5);
		冷却时间=60.0f;

		float 数据表1[技能等级上限]={
			0.0f,
			157.44, 173.41, 189.36, 205.34, 221.31,  237.30, 253.27, 269.23, 285.19, 301.16, 
			317.14, 333.12, 349.08, 365.06, 381.03,  396.99, 412.97, 428.94, 444.91, 460.88, 
			476.85, 492.82, 508.79, 524.76, 540.73,  556.70, 572.67, 588.64, 604.61, 620.58, 
			636.55, 652.52, 668.49, 684.46, 700.43,  716.40, 732.37, 748.34, 764.31, 780.28, 
			796.25, 812.22, 828.19, 844.16, 860.13,  876.10, 892.07, 908.04, 924.01, 939.98, 
		};

		float 数据表2[技能等级上限]={
			0.0f,
			78.71, 86.69, 94.68, 102.67, 110.66,  118.64, 126.64, 134.61, 142.59, 150.59, 
			158.56, 166.55, 174.54, 182.52, 190.52,  198.50, 206.48, 214.47, 222.45, 230.43, 
			238.41, 246.39, 254.37, 262.35, 270.33,  278.31, 286.29, 294.27, 302.25, 310.23, 
			318.21, 326.19, 334.17, 342.15, 350.13,  358.11, 366.09, 374.07, 382.05, 390.03, 
			398.01, 405.99, 413.97, 421.95, 429.93,  437.91, 445.89, 453.87, 461.85, 469.83, 
		};

		float 数据表3[技能等级上限]={
			0.0f,
			1102.01, 1213.80, 1325.58, 1437.40, 1549.21,  1661.00, 1772.79, 1884.59, 1996.38, 2108.19, 
			2219.98, 2331.79, 2443.58, 2555.38, 2667.17,  2778.98, 2890.77, 3002.56, 3114.36, 3226.16, 
			3337.96, 3449.76, 3561.56, 3673.36, 3785.16,  3896.96, 4008.76, 4120.56, 4232.36, 4344.16, 
			4455.96, 4567.76, 4679.56, 4791.36, 4903.16,  5014.96, 5126.76, 5238.56, 5350.36, 5462.16, 
			5573.96, 5685.76, 5797.56, 5909.36, 6021.16,  6132.96, 6244.76, 6356.56, 6468.36, 6580.16, 
		};

		数据表数量=3;
		数据表[0]=数据表1;
		数据表[1]=数据表2;
		数据表[2]=数据表3;

		ResId=RID_技能图标_剑帝+落英惊鸿掌;

		白金徽章可选=FALSE;
		时装上衣可选=FALSE;
	}

	virtual float 获取伤害(int 等级,int TP等级=0,BOOL 应用护石=FALSE)
	{
		float 基础伤害=(数据表[0])[等级]+(数据表[1])[等级]*4+(数据表[2])[等级];	//1+4+1段
		return 基础伤害;
	}

	virtual float 获取冷却(BOOL 应用护石=FALSE)
	{
		return 冷却时间;
	}
};

class DNF技能对象_轻云出月风静夜 : public DNF技能对象
{
public:
	virtual void 初始化()
	{
		索引=轻云出月风静夜;
		名称=L"轻云出月风静夜";
		所属职业=职业_流浪武士;
		技能类型=觉醒技能;
		可用护石=FALSE;
		可用符文=FALSE;
		可用TP=FALSE;

		学习等级=100;
		等级上限=50;
		精通等级=40;
		版本等级=4;

		无色数量=15;
		手搓冷却缩减=PC(5);
		冷却时间=290.0f;

		float 数据表1[技能等级上限]={
			0.0f,
			6112.71, 7530.17, 8947.59, 10365.04, 11782.47,  13199.92, 14617.36, 16034.81, 17452.25, 18869.70, 
			20287.14, 21704.58, 23122.02, 24539.46, 25956.90,  27374.34, 28791.78, 30209.22, 31626.66, 33044.10, 
			34461.54, 35878.98, 37296.42, 38713.86, 40131.30,  41548.74, 42966.18, 44383.62, 45801.06, 47218.50, 
			48635.94, 50053.38, 51470.82, 52888.26, 54305.70,  55723.14, 57140.58, 58558.02, 59975.46, 61392.90, 
			62810.34, 64227.78, 65645.22, 67062.66, 68480.10,  69897.54, 71314.98, 72732.42, 74149.86, 75567.30, 
		};

		数据表数量=1;
		数据表[0]=数据表1;

		ResId=RID_技能图标_剑帝+轻云出月风静夜;

		白金徽章可选=FALSE;
		时装上衣可选=FALSE;
	}

	virtual float 获取伤害(int 等级,int TP等级=0,BOOL 应用护石=FALSE)
	{
		float 基础伤害=(数据表[0])[等级];
		return 基础伤害;
	}

	virtual float 获取冷却(BOOL 应用护石=FALSE)
	{
		return 冷却时间;
	}
};

class DNF技能对象_光剑掌握 : public DNF技能对象
{
public:
	virtual void 初始化()
	{
		索引=光剑掌握;
		名称=L"光剑掌握";
		所属职业=职业_流浪武士;
		技能类型=被动技能;

		学习等级=1;
		等级上限=1;
		精通等级=1;
		版本等级=1;

		数据表数量=0;

		ResId=RID_技能图标_剑帝+光剑掌握;

		白金徽章可选=FALSE;
		时装上衣可选=FALSE;
	}

	virtual void 应用被动技能(int 等级,PVOID 角色对象)
	{
		//待实现

		//冷却
	}
};

class DNF技能对象_返本归元 : public DNF技能对象
{
public:
	virtual void 初始化()
	{
		索引=返本归元;
		名称=L"返本归元";
		所属职业=职业_流浪武士;
		技能类型=被动技能;

		学习等级=20;
		等级上限=11;
		精通等级=1;
		版本等级=1;

		//技攻
		float 数据表1[技能等级上限]={
			0.0f,
			PC(20.0), PC(24.0), PC(28.0), PC(32.0), PC(36.0), 
			PC(40.0), PC(44.0), PC(48.0), PC(52.0), PC(56.0), 
			PC(60.0), 
		};

		//物理暴击
		float 数据表2[技能等级上限]={
			0.0f,
			PC(20.0), PC(20.0), PC(20.0), PC(20.0), PC(20.0), 
			PC(20.0), PC(20.0), PC(20.0), PC(20.0), PC(20.0), 
			PC(20.0), 
		};

		数据表数量=2;
		数据表[0]=数据表1;
		数据表[1]=数据表2;

		ResId=RID_技能图标_剑帝+返本归元;

		白金徽章可选=TRUE;
		时装上衣可选=TRUE;
	}

	virtual void 应用被动技能(int 等级,PVOID 角色对象)
	{
		//待实现

		//技攻
	}
};

class DNF技能对象_三花聚顶 : public DNF技能对象
{
public:
	virtual void 初始化()
	{
		索引=三花聚顶;
		名称=L"三花聚顶";
		所属职业=职业_流浪武士;
		技能类型=被动技能;

		学习等级=48;
		等级上限=50;
		精通等级=40;
		版本等级=23;

		//技攻
		float 数据表1[技能等级上限]={
			0.0f,
			PC(8.5), PC(10.5), PC(12.5), PC(14.5), PC(16.5), 
			PC(18.5), PC(20.5), PC(22.5), PC(24.5), PC(26.5), 
			PC(28.5), PC(30.5), PC(32.5), PC(34.5), PC(36.5), 
			PC(38.5), PC(40.5), PC(42.5), PC(44.5), PC(46.5), 
			PC(48.5), PC(50.5), PC(52.5), PC(54.5), PC(56.5), 
			PC(58.5), PC(60.5), PC(62.5), PC(64.5), PC(66.5), 
			PC(68.5), PC(70.5), PC(72.5), PC(74.5), PC(76.5), 
			PC(78.5), PC(80.5), PC(82.5), PC(84.5), PC(86.5), 
			PC(88.5), PC(90.5), PC(92.5), PC(94.5), PC(96.5), 
			PC(98.5), PC(100.5), PC(102.5), PC(104.5), PC(106.5), 
		};

		数据表数量=1;
		数据表[0]=数据表1;

		ResId=RID_技能图标_剑帝+三花聚顶;

		白金徽章可选=FALSE;
		时装上衣可选=TRUE;
	}

	virtual void 应用被动技能(int 等级,PVOID 角色对象)
	{
		//待实现

		//解除异常时，可加攻速和移速
		//技攻
	}
};

class DNF技能对象_七星耀华 : public DNF技能对象
{
public:
	virtual void 初始化()
	{
		索引=七星耀华;
		名称=L"七星耀华";
		所属职业=职业_流浪武士;
		技能类型=被动技能;

		学习等级=75;
		等级上限=50;
		精通等级=40;
		版本等级=14;

		//技攻
		float 数据表1[技能等级上限]={
			0.0f,
			PC(20.0), PC(22.0), PC(24.0), PC(26.0), PC(28.0), 
			PC(30.0), PC(32.0), PC(34.0), PC(36.0), PC(38.0), 
			PC(40.0), PC(42.0), PC(44.0), PC(46.0), PC(48.0), 
			PC(50.0), PC(52.0), PC(54.0), PC(56.0), PC(58.0), 
			PC(60.0), PC(62.0), PC(64.0), PC(66.0), PC(68.0), 
			PC(70.0), PC(72.0), PC(74.0), PC(76.0), PC(78.0), 
			PC(80.0), PC(82.0), PC(84.0), PC(86.0), PC(88.0), 
			PC(90.0), PC(92.0), PC(94.0), PC(96.0), PC(98.0), 
			PC(100.0), PC(102.0), PC(104.0), PC(106.0), PC(108.0), 
			PC(110.0), PC(112.0), PC(114.0), PC(116.0), PC(118.0), 
		};

		数据表数量=1;
		数据表[0]=数据表1;

		ResId=RID_技能图标_剑帝+七星耀华;

		白金徽章可选=FALSE;
		时装上衣可选=TRUE;
	}

	virtual void 应用被动技能(int 等级,PVOID 角色对象)
	{
		//待实现

		//低级技能不加技攻
		//技攻
	}
};

class DNF技能对象_仙剑之境 : public DNF技能对象
{
public:
	virtual void 初始化()
	{
		索引=仙剑之境;
		名称=L"仙剑之境";
		所属职业=职业_流浪武士;
		技能类型=被动技能;

		学习等级=95;
		等级上限=50;
		精通等级=40;
		版本等级=7;

		//技攻
		float 数据表1[技能等级上限]={
			0.0f,
			PC(20.0), PC(22.0), PC(24.0), PC(26.0), PC(28.0), 
			PC(30.0), PC(32.0), PC(34.0), PC(36.0), PC(38.0), 
			PC(40.0), PC(42.0), PC(44.0), PC(46.0), PC(48.0), 
			PC(50.0), PC(52.0), PC(54.0), PC(56.0), PC(58.0), 
			PC(60.0), PC(62.0), PC(64.0), PC(66.0), PC(68.0), 
			PC(70.0), PC(72.0), PC(74.0), PC(76.0), PC(78.0), 
			PC(80.0), PC(82.0), PC(84.0), PC(86.0), PC(88.0), 
			PC(90.0), PC(92.0), PC(94.0), PC(96.0), PC(98.0), 
			PC(100.0), PC(102.0), PC(104.0), PC(106.0), PC(108.0), 
			PC(110.0), PC(112.0), PC(114.0), PC(116.0), PC(118.0), 
		};

		数据表数量=1;
		数据表[0]=数据表1;

		ResId=RID_技能图标_剑帝+仙剑之境;

		白金徽章可选=FALSE;
		时装上衣可选=FALSE;
	}

	virtual void 应用被动技能(int 等级,PVOID 角色对象)
	{
		//待实现

		//低级技能不加技攻
		//技攻

		//影响一花渡江冷却
	}
};






class DNF流浪武士 : public DNF职业对象
{
public:
	virtual void 初始化()
	{
		职业=职业_流浪武士;
		攻击类型=物理攻击类型;
		是否固伤=FALSE;
		是否辅助=FALSE;
		//技能总数量=23;
		主动技能数量=18;
		被动技能数量=5;
		被动技能索引=18;

		技能总数量=0;
		std::vector<DNF技能对象*>::iterator it;
		for (it=技能对象表.begin();it!=技能对象表.end();it++)
		{
			if ((*it)->所属职业==职业_流浪武士)
			{
				职业技能列表[技能总数量]=*it;
				技能总数量++;
			}	
		}

		Buff图标ResId=RID_BUFF技能图标_剑帝;

		//每次设置变更时，由转换函数填充设置相关的字段
		//每次重新计算时，由计算核心重置并填充动态数据
	}

	virtual void 应用职业基本数据(PVOID 角色对象)
	{
		//待实现
	}

	virtual void 应用被动技能(int 技能索引,PVOID 角色对象)
	{
		//待实现
	}

	virtual double 计算技能单次伤害(int 技能索引,PVOID 角色对象)
	{
		//待实现
		return 0.0;
	}

	virtual double 计算技能总伤害(int 技能索引,PVOID 角色对象)
	{
		//待实现
		return 0.0;
	}

	virtual double 计算技能冷却(int 技能索引,PVOID 角色对象)
	{
		//待实现
		return 0.0;
	}

	virtual int 计算技能等级(int 技能索引,PVOID 角色对象)
	{
		//待实现
		return 0.0;
	}
};


void 添加技能对象_剑帝()
{
	int Size=技能对象表.size();
	技能对象表.push_back(new DNF技能对象_四象引);
	技能对象表.push_back(new DNF技能对象_一花渡江);
	技能对象表.push_back(new DNF技能对象_樱落斩);
	技能对象表.push_back(new DNF技能对象_碎岩裂地掌);
	技能对象表.push_back(new DNF技能对象_圆舞斩);
	技能对象表.push_back(new DNF技能对象_乱花葬);
	技能对象表.push_back(new DNF技能对象_游龙掌);
	技能对象表.push_back(new DNF技能对象_湮烈掌);
	技能对象表.push_back(new DNF技能对象_回天璇鸣剑);
	技能对象表.push_back(new DNF技能对象_花舞千魂);
	技能对象表.push_back(new DNF技能对象_花开寒影);
	技能对象表.push_back(new DNF技能对象_啸空十字刃);
	技能对象表.push_back(new DNF技能对象_如来神掌);
	技能对象表.push_back(new DNF技能对象_莲花剑舞);
	技能对象表.push_back(new DNF技能对象_樱花劫);
	技能对象表.push_back(new DNF技能对象_飞花逐月);
	技能对象表.push_back(new DNF技能对象_落英惊鸿掌);
	技能对象表.push_back(new DNF技能对象_轻云出月风静夜);
	技能对象表.push_back(new DNF技能对象_光剑掌握);
	技能对象表.push_back(new DNF技能对象_返本归元);
	技能对象表.push_back(new DNF技能对象_三花聚顶);
	技能对象表.push_back(new DNF技能对象_七星耀华);
	技能对象表.push_back(new DNF技能对象_仙剑之境);
	std::vector<DNF技能对象*>::iterator it;
	for (it=技能对象表.begin()+Size;it!=技能对象表.end();it++)
		(*it)->初始化();
}

void 添加职业对象_剑帝()
{
	auto Object=new DNF流浪武士;
	Object->初始化();
	职业对象表.push_back(Object);
}